{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Huggingface Sagemaker-sdk - training with custom metrics\n",
    "### Binary Classification with `Trainer` and `imdb` dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this demo, we extend the basic classification demo by adding **metrics definition** to capture and visualize training metrics.\n",
    "\n",
    "The documentation of the SageMaker metrics capture feature can be seen at https://docs.aws.amazon.com/sagemaker/latest/dg/training-metrics.html\n",
    "\n",
    "We additionally use **SageMaker Checkpointing** to send intermediary checkpoint data to S3 uncompressed in parallel to the training happening https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html\n",
    "\n",
    "\n",
    "SageMaker Checkpointing is supported by HF Trainer after Transformers 4.4.0+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import libraries and set environment\n",
    "\n",
    "_*Note:* we only install the required libraries from Hugging Face and AWS. You also need PyTorch or Tensorflow, if you haven´t it installed_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install \"sagemaker>=2.48.0\" \"transformers==4.6.1\" \"datasets[s3]==1.6.2\" --upgrade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Development environment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**upgrade ipywidgets for `datasets` library and restart kernel, only needed when prerpocessing is done in the notebook**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "import IPython\n",
    "!conda install -c conda-forge ipywidgets -y\n",
    "IPython.Application.instance().kernel.do_shutdown(True) # has to restart kernel so changes are used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sagemaker.huggingface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permissions\n",
    "\n",
    "_If you are going to use Sagemaker in a local environment. You need access to an IAM Role with the required permissions for Sagemaker. You can find [here](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) more about it._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sagemaker\n",
    "\n",
    "sess = sagemaker.Session()\n",
    "# sagemaker session bucket -> used for uploading data, models and logs\n",
    "# sagemaker will automatically create this bucket if it not exists\n",
    "sagemaker_session_bucket=None\n",
    "if sagemaker_session_bucket is None and sess is not None:\n",
    "    # set to default bucket if a bucket name is not given\n",
    "    sagemaker_session_bucket = sess.default_bucket()\n",
    "\n",
    "role = sagemaker.get_execution_role()\n",
    "sess = sagemaker.Session(default_bucket=sagemaker_session_bucket)\n",
    "\n",
    "print(f\"sagemaker role arn: {role}\")\n",
    "print(f\"sagemaker bucket: {sess.default_bucket()}\")\n",
    "print(f\"sagemaker session region: {sess.boto_region_name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing\n",
    "\n",
    "We are using the `datasets` library to download and preprocess the `imdb` dataset. After preprocessing, the dataset will be uploaded to our `sagemaker_session_bucket` to be used within our training job. The [imdb](http://ai.stanford.edu/~amaas/data/sentiment/) dataset consists of 25000 training and 25000 testing highly polar movie reviews."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenization "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "from transformers import AutoTokenizer\n",
    "\n",
    "# tokenizer used in preprocessing\n",
    "tokenizer_name = 'distilbert-base-uncased'\n",
    "\n",
    "# dataset used\n",
    "dataset_name = 'imdb'\n",
    "\n",
    "# s3 key prefix for the data\n",
    "s3_prefix = 'samples/datasets/imdb'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load dataset\n",
    "dataset = load_dataset(dataset_name)\n",
    "\n",
    "# download tokenizer\n",
    "tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)\n",
    "\n",
    "# tokenizer helper function\n",
    "def tokenize(batch):\n",
    "    return tokenizer(batch['text'], padding='max_length', truncation=True)\n",
    "\n",
    "# load dataset\n",
    "train_dataset, test_dataset = load_dataset('imdb', split=['train', 'test'])\n",
    "test_dataset = test_dataset.shuffle().select(range(10000)) # smaller the size for test dataset to 10k \n",
    "\n",
    "\n",
    "# tokenize dataset\n",
    "train_dataset = train_dataset.map(tokenize, batched=True)\n",
    "test_dataset = test_dataset.map(tokenize, batched=True)\n",
    "\n",
    "# set format for pytorch\n",
    "train_dataset =  train_dataset.rename_column(\"label\", \"labels\")\n",
    "train_dataset.set_format('torch', columns=['input_ids', 'attention_mask', 'labels'])\n",
    "test_dataset = test_dataset.rename_column(\"label\", \"labels\")\n",
    "test_dataset.set_format('torch', columns=['input_ids', 'attention_mask', 'labels'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uploading data to Amazon S3\n",
    "\n",
    "After we processed the `datasets` we are going to use the new `FileSystem` [integration](https://huggingface.co/docs/datasets/filesystems.html) to upload our dataset to S3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import botocore\n",
    "from datasets.filesystems import S3FileSystem\n",
    "\n",
    "s3 = S3FileSystem()  \n",
    "\n",
    "# save train_dataset to s3\n",
    "training_input_path = f's3://{sess.default_bucket()}/{s3_prefix}/train'\n",
    "train_dataset.save_to_disk(training_input_path,fs=s3)\n",
    "\n",
    "# save test_dataset to s3\n",
    "test_input_path = f's3://{sess.default_bucket()}/{s3_prefix}/test'\n",
    "test_dataset.save_to_disk(test_input_path,fs=s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Launching a Training Job with custom metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sagemaker.huggingface import HuggingFace\n",
    "\n",
    "# hyperparameters, which will be passed into the training job\n",
    "hyperparameters={\n",
    "    'epochs': 3,\n",
    "    'train_batch_size': 32,\n",
    "    'checkpoints': '/opt/ml/checkpoints/',\n",
    "    'model_name':'distilbert-base-uncased'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a metric_definition dictionary that contains regex-based definitions that will be used to parse the job logs and extract metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "metric_definitions=[\n",
    "    {'Name': 'loss', 'Regex': \"'loss': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'learning_rate', 'Regex': \"'learning_rate': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_loss', 'Regex': \"'eval_loss': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_accuracy', 'Regex': \"'eval_accuracy': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_f1', 'Regex': \"'eval_f1': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_precision', 'Regex': \"'eval_precision': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_recall', 'Regex': \"'eval_recall': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_runtime', 'Regex': \"'eval_runtime': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'eval_samples_per_second', 'Regex': \"'eval_samples_per_second': ([0-9]+(.|e\\-)[0-9]+),?\"},\n",
    "    {'Name': 'epoch', 'Regex': \"'epoch': ([0-9]+(.|e\\-)[0-9]+),?\"}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "huggingface_estimator = HuggingFace(\n",
    "    entry_point='train.py',\n",
    "    source_dir='./scripts',\n",
    "    instance_type='ml.p3.2xlarge',\n",
    "    instance_count=1,\n",
    "    transformers_version='4.6',\n",
    "    pytorch_version='1.7',\n",
    "    py_version='py36',\n",
    "    role=role,\n",
    "    hyperparameters=hyperparameters,\n",
    "    metric_definitions=metric_definitions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# starting the train job with our uploaded datasets as input\n",
    "huggingface_estimator.fit({'train': training_input_path, 'test': test_input_path})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Training Metrics\n",
    "\n",
    "The training job doesn't emit metrics immediately. For example, it first needs to provision a training instance, download the training image, download the data. Additionally in this demo the first evaluation logs come after 500 steps (default in the Hugging Face trainer https://huggingface.co/transformers/main_classes/trainer.html#transformers.TrainingArguments).\n",
    "\n",
    "Hence, **run the below section 15 to 20 minutes after launching the training, otherwise it may not have available metrics yet and return an error**\n",
    "\n",
    "Note that you can also copy this code and run it from a different place (as long as connected to the cloud and authorized to use the API), by specifiying the exact training job name in the `TrainingJobAnalytics` API call.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>timestamp</th>\n",
       "      <th>metric_name</th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>loss</td>\n",
       "      <td>0.350000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>360.0</td>\n",
       "      <td>loss</td>\n",
       "      <td>0.212700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>600.0</td>\n",
       "      <td>loss</td>\n",
       "      <td>0.161600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>900.0</td>\n",
       "      <td>loss</td>\n",
       "      <td>0.076700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>learning_rate</td>\n",
       "      <td>0.000050</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>360.0</td>\n",
       "      <td>learning_rate</td>\n",
       "      <td>3.645720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>600.0</td>\n",
       "      <td>learning_rate</td>\n",
       "      <td>2.291441</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>900.0</td>\n",
       "      <td>learning_rate</td>\n",
       "      <td>9.371614</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.0</td>\n",
       "      <td>eval_loss</td>\n",
       "      <td>0.269111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>420.0</td>\n",
       "      <td>eval_loss</td>\n",
       "      <td>0.213563</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   timestamp    metric_name     value\n",
       "0        0.0           loss  0.350000\n",
       "1      360.0           loss  0.212700\n",
       "2      600.0           loss  0.161600\n",
       "3      900.0           loss  0.076700\n",
       "4        0.0  learning_rate  0.000050\n",
       "5      360.0  learning_rate  3.645720\n",
       "6      600.0  learning_rate  2.291441\n",
       "7      900.0  learning_rate  9.371614\n",
       "8        0.0      eval_loss  0.269111\n",
       "9      420.0      eval_loss  0.213563"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sagemaker import TrainingJobAnalytics\n",
    "\n",
    "# Captured metrics can be accessed as a Pandas dataframe\n",
    "df = TrainingJobAnalytics(training_job_name=huggingface_estimator.latest_training_job.name).dataframe()\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot some of the metrics collected\n",
    "\n",
    "*Note: the plot below were generated at the end of the training job, with metrics available for all training duration*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "plt.rcParams['figure.figsize'] = [15,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:label='8b8c5c4f-4666-47d2-aaa5-520ae383cfc4', xlabel='timestamp', ylabel='value'>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evals = df[df.metric_name.isin(['eval_accuracy','eval_precision'])]\n",
    "losses = df[df.metric_name.isin(['loss', 'eval_loss'])]\n",
    "\n",
    "sns.lineplot(\n",
    "    x='timestamp', \n",
    "    y='value', \n",
    "    data=evals, \n",
    "    hue='metric_name', \n",
    "    palette=['blue', 'purple'])\n",
    "\n",
    "ax2 = plt.twinx()\n",
    "sns.lineplot(\n",
    "    x='timestamp', \n",
    "    y='value', \n",
    "    data=losses, \n",
    "    hue='metric_name', \n",
    "    palette=['orange', 'red'],\n",
    "    ax=ax2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deploying the endpoint\n",
    "\n",
    "To deploy our endpoint, we call `deploy()` on our HuggingFace estimator object, passing in our desired number of instances and instance type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictor = huggingface_estimator.deploy(1,\"ml.g4dn.xlarge\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we use the returned predictor object to call the endpoint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentiment_input= {\"inputs\":\"I love using the new Inference DLC.\"}\n",
    "\n",
    "predictor.predict(sentiment_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we delete the endpoint again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictor.delete_endpoint()"
   ]
  }
 ],
 "metadata": {
  "instance_type": "ml.m5.xlarge",
  "interpreter": {
   "hash": "c281c456f1b8161c8906f4af2c08ed2c40c50136979eaae69688b01f70e9f4a9"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('hf': conda)",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}